// #include<iostream>
// using namespace std;
// class Test{
// public:
//     //定义一个拷贝构造
//     Test(const Test& t){
//         _num = t._num;
//         cout << "拷贝构造被调用" << endl;
//     }    
//     Test(int num = 0){
//         _num = num;
//     }

// private:
//     int _num;
// };
// void f1(Test& t){

// }
// Test& f2(){
//     static Test t2;
//     return t2;
// }
// int main(){
//     Test t1;
//     f1(t1);//对象作为参数进行传递，如果函数的形参是传值调用，那么就会调用拷贝构造，造成额外开销
//            //如果函数的形参是传引用调用，那么就不会调用拷贝构造，不会造成额外开销
//     f2();//对象作为返回值进行return，那么如果不是传引用而是传值，那么return t2的时候还是会调用
//         //拷贝构造创建一个临时存储的Test类型，而如果是传引用，那么就不会调用拷贝构造
//         //前提条件：返回的结果要在函数销毁以后存在。
//     return 0;
// }

// #include<iostream>
// using namespace std;
// class A{
// public:
//     //普通构造
//     A(){n++;}
//     //拷贝构造
//     A(const A& a){n++;}
//     //创建一个函数用以返回n的值
//     static int GetN(){//静态函数没有this指针，只能访问类中的静态变量，不能访问非静态的变量
//         // _a = 10;不能访问
//         return n;
//     }

// private:
//     int _a;
//     static int n;//这儿的n存储在静态区中
// };

// int A::n = 0;

// A& f1(A& a){//这儿形式参数用引用就不用访问拷贝构造，返回值用引用也不用访问拷贝构造。
//     return a;
// }
// int main(){
//     A a1;
//     A a2;
    
//     f1(a1);
//     f1(a2);
//     cout << A::GetN() << endl;  // 输出A类的静态成员变量n的值

//     return 0;
// }

//友元函数
#include<iostream>
using namespace std;
class Date{
    friend void Modify(Date& d);
public:
    void Print(){
        cout << _year << " " << _month << " " << _day << endl;
    }
private:
    int _year = 0;
    int _month = 1;
    int _day = 1;
};

void Modify(Date& d){
    d._year = 2025;
}

int main(){
    Date d1;
    Modify(d1);
    d1.Print();
    return 0;
}